"""
MCP服务器主入口
提供4个核心工具：代码质量分析、重构建议、坏味道检测、测试用例生成
"""
import json
import logging
from typing import Optional
from fastmcp import FastMCP
from llm_integration import LLMService
from code_analyzer import CodeAnalyzer
from review_engine import ReviewEngine
from utils import (
    validate_code_input,
    format_quality_report,
    format_refactoring_suggestions,
    format_test_cases
)

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

# 创建MCP服务器实例
mcp = FastMCP("mcp-code-reviewer 🔍")

# 初始化服务
llm_service = LLMService()
code_analyzer = CodeAnalyzer(llm_service)
review_engine = ReviewEngine(llm_service)


@mcp.tool()
async def analyze_code_quality(
    code: str,
    language: str = "python",
    context: Optional[str] = None,
    explanation: Optional[str] = None  # 通义灵码可能传入的额外参数
) -> str:
    """
    分析代码质量，提供质量评分和改进建议
    
    Args:
        code: 代码内容（字符串）
        language: 编程语言类型（python, javascript, java, go, rust等）
        context: 代码上下文信息（可选），用于更好地理解代码的业务逻辑
    
    Returns:
        JSON格式的质量报告，包含：
        - score: 质量评分（0-100）
        - issues: 问题列表（bug、性能、可维护性等）
        - strengths: 代码优点
        - improvements: 改进建议
    """
    try:
        # 验证输入
        is_valid, error_msg = validate_code_input(code, language)
        if not is_valid:
            return json.dumps({
                "error": error_msg,
                "score": 0
            }, ensure_ascii=False, indent=2)
        
        # 执行代码质量分析
        logger.info(f"开始分析代码质量，语言: {language}")
        result = await code_analyzer.analyze_code(code, language, context)
        
        # 格式化输出
        formatted_result = format_quality_report(result)
        logger.info("代码质量分析完成")
        
        # 返回JSON格式的结果
        return json.dumps(result, ensure_ascii=False, indent=2)
    
    except Exception as e:
        logger.error(f"代码质量分析失败: {str(e)}")
        return json.dumps({
            "error": f"分析失败: {str(e)}",
            "score": 0
        }, ensure_ascii=False, indent=2)


@mcp.tool()
async def suggest_refactoring(
    code: str,
    language: str = "python",
    refactoring_type: str = "general",
    explanation: Optional[str] = None  # 通义灵码可能传入的额外参数
) -> str:
    """
    提供代码重构建议
    
    Args:
        code: 代码内容（字符串）
        language: 编程语言类型
        refactoring_type: 重构类型，可选值：
            - "performance": 性能优化
            - "readability": 可读性提升
            - "design_pattern": 设计模式应用
            - "simplification": 代码简化
            - "general": 通用重构建议
    
    Returns:
        JSON格式的响应，包含两个字段：
        - markdown: Markdown格式的重构建议（包含代码高亮的代码片段）
        - json: 原始JSON数据
        
        重构建议包含：
        - refactoring_type: 重构类型
        - current_issues: 当前问题列表
        - suggestions: 重构建议列表（包含完整的重构前后代码片段）
    """
    try:
        # 验证输入
        is_valid, error_msg = validate_code_input(code, language)
        if not is_valid:
            return json.dumps({
                "error": error_msg
            }, ensure_ascii=False, indent=2)
        
        # 执行重构建议分析
        logger.info(f"开始生成重构建议，语言: {language}, 类型: {refactoring_type}")
        result = await llm_service.suggest_refactoring(code, language, refactoring_type)
        
        logger.info("重构建议生成完成")
        
        # 格式化为Markdown格式
        markdown_output = format_refactoring_suggestions(result, language)
        
        # 同时返回JSON和Markdown格式，JSON用于程序处理，Markdown用于显示
        return json.dumps({
            "markdown": markdown_output,
            "json": result
        }, ensure_ascii=False, indent=2)
    
    except Exception as e:
        logger.error(f"重构建议生成失败: {str(e)}")
        return json.dumps({
            "error": f"生成失败: {str(e)}"
        }, ensure_ascii=False, indent=2)


@mcp.tool()
async def detect_code_smells(
    code: str,
    language: str = "python",
    explanation: Optional[str] = None  # 通义灵码可能传入的额外参数
) -> str:
    """
    检测代码坏味道（Code Smells）
    
    常见的代码坏味道包括：
    - 长方法（Long Method）
    - 大类（Large Class）
    - 重复代码（Duplicated Code）
    - 长参数列表（Long Parameter List）
    - 数据泥团（Data Clumps）
    - 特征依恋（Feature Envy）
    - 魔法数字（Magic Numbers）
    等等
    
    Args:
        code: 代码内容（字符串）
        language: 编程语言类型
    
    Returns:
        JSON格式的坏味道检测结果，包含：
        - smells: 坏味道列表（类型、严重程度、位置、描述、影响、修复建议）
        - summary: 总体评价
    """
    try:
        # 验证输入
        is_valid, error_msg = validate_code_input(code, language)
        if not is_valid:
            return json.dumps({
                "error": error_msg
            }, ensure_ascii=False, indent=2)
        
        # 执行坏味道检测
        logger.info(f"开始检测代码坏味道，语言: {language}")
        result = await llm_service.detect_code_smells(code, language)
        
        logger.info("代码坏味道检测完成")
        return json.dumps(result, ensure_ascii=False, indent=2)
    
    except Exception as e:
        logger.error(f"坏味道检测失败: {str(e)}")
        return json.dumps({
            "error": f"检测失败: {str(e)}"
        }, ensure_ascii=False, indent=2)


@mcp.tool()
async def generate_test_cases(
    code: str,
    language: str = "python",
    test_framework: str = "default",
    explanation: Optional[str] = None  # 通义灵码可能传入的额外参数
) -> str:
    """
    基于代码生成测试用例建议
    
    Args:
        code: 代码内容（字符串）
        language: 编程语言类型
        test_framework: 测试框架类型，例如：
            - Python: "pytest", "unittest", "default"
            - JavaScript: "jest", "mocha", "default"
            - Java: "junit", "testng", "default"
            - 其他语言使用 "default"
    
    Returns:
        JSON格式的响应，包含两个字段：
        - markdown: Markdown格式的测试用例（包含代码高亮的完整测试代码）
        - json: 原始JSON数据
        
        测试用例包含：
        - test_cases: 测试用例列表（包含完整的、可运行的测试代码）
        - coverage_analysis: 覆盖率分析（已覆盖、缺失的测试场景）
    """
    try:
        # 验证输入
        is_valid, error_msg = validate_code_input(code, language)
        if not is_valid:
            return json.dumps({
                "error": error_msg
            }, ensure_ascii=False, indent=2)
        
        # 执行测试用例生成
        logger.info(f"开始生成测试用例，语言: {language}, 框架: {test_framework}")
        result = await llm_service.generate_test_cases(code, language, test_framework)
        
        logger.info("测试用例生成完成")
        
        # 格式化为Markdown格式
        markdown_output = format_test_cases(result, language, test_framework)
        
        # 同时返回JSON和Markdown格式，JSON用于程序处理，Markdown用于显示
        return json.dumps({
            "markdown": markdown_output,
            "json": result
        }, ensure_ascii=False, indent=2)
    
    except Exception as e:
        logger.error(f"测试用例生成失败: {str(e)}")
        return json.dumps({
            "error": f"生成失败: {str(e)}"
        }, ensure_ascii=False, indent=2)


def main():
    """启动MCP服务器"""
    mcp.run(
        transport="sse",
        host="0.0.0.0",
        port=8000,
        path="/mcp",
        log_level="info",
    )


if __name__ == "__main__":
    main()

